/*============================================================================*/
/*  Copyright (C) 2009-2011, iSOFT INFRASTRUCTURE SOFTWARE CO.,LTD.
 *
 *  All rights reserved. This software is iSOFT property. Duplication
 *  or disclosure without iSOFT written authorization is prohibited.
 *
 *  @file       <Can_Irq.c>
 *  @brief      <Can Irq Isr Source code>
 *
 * <Compiler: TASKING V3.5    MCU:tc1782>
 *
 *  @author     <jianan.liu>
 *  @date       <03-18-2014>
 */
/*============================================================================*/

/*=======[R E V I S I O N   H I S T O R Y]====================================*/
/*  <VERSION>    <DATE>    <AUTHOR>    <REVISION LOG>
 *  V1.0.0       20140318  jianan.liu   Initial version
 */
/*============================================================================*/

/*=======[V E R S I O N  I N F O R M A T I O N]===============================*/
#define CAN_IRQ_C_AR_MAJOR_VERSION      2
#define CAN_IRQ_C_AR_MINOR_VERSION      4
#define CAN_IRQ_C_AR_PATCH_VERSION      0
#define CAN_IRQ_C_SW_MAJOR_VERSION      1
#define CAN_IRQ_C_SW_MINOR_VERSION      0
#define CAN_IRQ_C_SW_PATCH_VERSION      1

/*=======[I N C L U D E S]====================================================*/
#include "Can.h"
#include "Can_Irq.h"

/*=======[V E R S I O N  C H E C K]===========================================*/
#if (CAN_IRQ_C_AR_MAJOR_VERSION != CAN_IRQ_H_AR_MAJOR_VERSION)
    #error "Can_Irq.c:Mismatch in Specification Major Version"
#endif 
#if (CAN_IRQ_C_AR_MINOR_VERSION != CAN_IRQ_H_AR_MINOR_VERSION)
    #error "Can_Irq.c:Mismatch in Specification Minor Version"
#endif
#if (CAN_IRQ_C_AR_PATCH_VERSION != CAN_IRQ_H_AR_PATCH_VERSION)
    #error "Can_Irq.c:Mismatch in Specification Patch Version"
#endif
#if (CAN_IRQ_C_SW_MAJOR_VERSION != CAN_IRQ_H_SW_MAJOR_VERSION)
    #error "Can_Irq.c:Mismatch in Specification Major Version"
#endif
#if (CAN_IRQ_C_SW_MINOR_VERSION != CAN_IRQ_H_SW_MINOR_VERSION)
    #error "Can_Irq.c:Mismatch in Specification Minor Version"
#endif

/*=======[F U N C T I O N   I M P L E M E N T A T I O N S]====================*/
#define CAN_START_SEC_CODE_FAST
#include "Can_MemMap.h"

/******************************************************************************/
/*
 * Brief               <CAN 0 BusOff Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER0_BUSOFF_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_0_BusOffISR(void)
{
    Can_BusOff_Handler(CAN_CONTROLLER_0);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 1 BusOff Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER1_BUSOFF_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_1_BusOffISR(void)
{
    Can_BusOff_Handler(CAN_CONTROLLER_1);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 2 BusOff Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER2_BUSOFF_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_2_BusOffISR(void)
{
    Can_BusOff_Handler(CAN_CONTROLLER_2);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 0 Rx Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER0_RX_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_0_RxISR(void)
{
    Can_RxProcess(CAN_CONTROLLER_0);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 1 Rx Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER1_RX_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_1_RxISR(void)
{
    Can_RxProcess(CAN_CONTROLLER_1);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 2 Rx Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER2_RX_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_2_RxISR(void)
{
    Can_RxProcess(CAN_CONTROLLER_2);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 0 Tx Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER0_TX_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_0_TxISR(void)
{
    Can_TxProcess(CAN_CONTROLLER_0);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 1 Tx Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER1_TX_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_1_TxISR(void)
{
    Can_TxProcess(CAN_CONTROLLER_1);
    return;
}
#endif

/******************************************************************************/
/*
 * Brief               <CAN 2 Tx Interrupt Service Routine process>
 * Param-Name[in]      <None>
 * Param-Name[out]     <None>
 * Param-Name[in/out]  <None>
 * Return              <None>
 * PreCondition        <None>
 * CallByAPI           <None>
 */
/******************************************************************************/
#if (CAN_CONTROLLER2_TX_INTERRUPT == STD_ON)
FUNC(void, CAN_CODE_FAST) Can_2_TxISR(void)
{
    Can_TxProcess(CAN_CONTROLLER_2);
    return;
}
#endif

#define CAN_STOP_SEC_CODE_FAST
#include "Can_MemMap.h"

/*=======[E N D   O F   F I L E]==============================================*/

